fn main() {
    println!("Hello, world!");
    let mut sieve=[true; 10000];
    for i in 2..100 {
        if sieve[i] {
            let mut j = i*i;
            while j < 10000 {
                sieve[j] = false;
                j += i;
            }
        }
    }
    for i in 2..10000 {
        if sieve[i] {
            print!("{} ", i);
        }
    }
    println!();
    let mut chaos = [3,5,4,1,2];
    chaos.sort();
    println!("{:?}", chaos);
    assert_eq!(chaos, [1,2,3,4,5]);

    let mut primes = vec![2,3,5,7];
    println!("{:?}", primes);
    println!("{:?}", primes.iter().product::<i32>());
    primes.push(11);
    primes.push(13);
    println!("{:?},len={}, cal={}", primes, primes.len(), primes.capacity());
    println!("{:?}", primes.iter().product::<i32>());

    let mut primes = new_pixel_buffer(10, 10);
    println!("{:?},len={}, cal={}", primes, primes.len(), primes.capacity());
    primes.push(11);
    primes.push(13);
    println!("{:?},len={}, cal={}", primes, primes.len(), primes.capacity());
    primes[0] = 255;
    println!("{:?},len={}, cal={}", primes, primes.len(), primes.capacity());

    let mut primes = new_pixel_buffer(10, 0);
    println!("{:?},len={}, cal={}", primes, primes.len(), primes.capacity());
    primes.push(11);
    primes.push(13);
    println!("{:?},len={}, cal={}", primes, primes.len(), primes.capacity());
    let mut primes = Vec::with_capacity(10);
    println!("{:?},len={}, cal={}", primes, primes.len(), primes.capacity());
    primes.push(11);
    primes.push(13);
    println!("{:?},len={}, cal={}", primes, primes.len(), primes.capacity());

    primes.remove(1);
    println!("remove {:?},len={}, cal={}", primes, primes.len(), primes.capacity());
    primes.pop();
    println!("pop {:?},len={}, cal={}", primes, primes.len(), primes.capacity());

    let v:Vec<i32> = (0..5).collect();
    println!("{:?},len={}, cal={}", v, v.len(), v.capacity());
    let v:Vec<i32> = (0..5).rev().collect();
    println!("{:?},len={}, cal={}", v, v.len(), v.capacity());
    let v:Vec<i32> = (0..5).map(|x| x*x).collect();
    println!("{:?},len={}, cal={}", v, v.len(), v.capacity());
    let v:Vec<i32> = (0..5).filter(|x| x%2==0).collect();
    println!("{:?},len={}, cal={}", v, v.len(), v.capacity());
    let v = (0..5).collect::<Vec<i32>>();
    println!("{:?},len={}, cal={}", v, v.len(), v.capacity());
    test_array();
    test_string();
    test_b_char();
}

fn new_pixel_buffer(rows: usize, cols: usize) -> Vec<u8> {
    vec![0; rows*cols*3]
}

fn test_array(){
    let v:Vec<f64> = vec![0.0, 0.707, 1.0, 0.707];
    let a:[f64; 4] = [0.0, 0.707, 1.0, 0.707];
    print(&v);
    print(&a);
    let sv:&[f64] = &v;
    let sa:&[f64] = &a;
    println!("sv = {:?}", sv);
    println!("sa = {:?}", sa);

    let bits = vec!["this", "is", "a", "test", "run"];
    let s = bits.join(" ");
    println!("s = {}", s);
    let s = bits.join("-");
    println!("join s = {}", s);
    let s = bits.concat();
    println!("concat s = {}", s);

}

fn print(a:&[f64]){
    for etl in a {
        println!("{} ", etl);
    }
}

fn test_string() {
    println!("这是一个测试字符串换行的
    打印，
    你看是不是输出中有换行信息");

    println!("这是一个测试字符串换行的\
    打印，\
    你看是不是输出中没有换行信息");
    println!("这是一个测试字符串换行的 c:\nuser\test 打印，你看是不是\"没有路径");
    // 使用r来表示原始字符串，不会转义
    println!(r"这是一个测试字符串换行的 c:\user\test 打印，你看使用R路径完整保留, 但是有一上问题就是不支持”引号输出
    枯克格勃");
    // 使用r#""#来表示原始字符串，不会转义
    println!(r#"这是一个测试字符串换行的 c:\user\test 打印，你看使用r#也是可以的，可以支持"输出"#);
}

fn test_b_char(){
    // 字节串与字符串相似，但是不支持UTF-8编码，只支持ASCII编码
    let b = b"hello";
    println!("{:?}", b);
    let b = br#"hello \n "world""#;
    println!("{:?}", b);
    let b = br##"hello \n "world""##;
    println!("{:?}", b);
}
